/// @tags: DP TreeChainPartition by Length
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <vector>

using namespace std;

namespace BlueQuantum {

typedef long long LL;

constexpr int MAXN = 2e5 + 3, SEGN = MAXN * 4, P = 998244353;

int n, lim, ans, dcnt;
int dep[MAXN], maxdep[MAXN], pos[MAXN];
int tag[SEGN], sum[SEGN];
vector<int> e[MAXN];

inline int inc(int x, int y) {
  x += y;
  return x >= P ? x - P : x;
}

inline int dec(int x, int y) {
  x -= y;
  return x < 0 ? x + P : x;
}

inline bool cmp(int x, int y) { return maxdep[x] > maxdep[y]; }

inline LL qpow(LL base, int exp = P - 2) {
  LL res = 1;
  for (; exp; exp >>= 1, base = base * base % P)
    if (exp & 1) res = res * base % P;
  return res;
}

void build(int x, int l, int r) {
  tag[x] = 1, sum[x] = 0;
  if (l == r) return;
  int mid = (l + r) >> 1;
  build(x << 1, l, mid);
  build(x << 1 | 1, mid + 1, r);
}

inline void pushUp(int x) { sum[x] = inc(sum[x << 1], sum[x << 1 | 1]); }

inline void pushDown(int x) {
  if (tag[x] != 1) {
    int ls = x << 1, rs = x << 1 | 1;
    sum[ls] = (LL)sum[ls] * tag[x] % P;
    sum[rs] = (LL)sum[rs] * tag[x] % P;
    tag[ls] = (LL)tag[ls] * tag[x] % P;
    tag[rs] = (LL)tag[rs] * tag[x] % P;
    tag[x] = 1;
  }
}

void add(int x, int l, int r, int pos, int val) {
  if (l == r) {
    sum[x] = inc(sum[x], val);
    return;
  }
  pushDown(x);
  int mid = (l + r) >> 1;
  pos <= mid ? add(x << 1, l, mid, pos, val) : add(x << 1 | 1, mid + 1, r, pos, val);
  pushUp(x);
}

int query(int x, int l, int r, int L, int R) {
  if (L <= l && r <= R) return sum[x];
  int mid = (l + r) >> 1, res = 0;
  pushDown(x);
  if (L <= mid) res = inc(res, query(x << 1, l, mid, L, R));
  if (mid < R) res = inc(res, query(x << 1 | 1, mid + 1, r, L, R));
  return res;
}

void multiply(int x, int l, int r, int L, int R, int k) {
  if (L <= l && r <= R) {
    sum[x] = (LL)sum[x] * k % P;
    tag[x] = (LL)tag[x] * k % P;
    return;
  }
  pushDown(x);
  int mid = (l + r) >> 1;
  if (L <= mid) multiply(x << 1, l, mid, L, R, k);
  if (mid < R) multiply(x << 1 | 1, mid + 1, r, L, R, k);
  pushUp(x);
}

void dfs1(int u, int fa) {
  if (fa) e[u].erase(find(e[u].begin(), e[u].end(), fa));
  maxdep[u] = dep[u] = dep[fa] + 1;
  for (auto v : e[u])
    if (v != fa) dfs1(v, u), maxdep[u] = max(maxdep[u], maxdep[v]);
}

void dfs2(int u) {
  sort(e[u].begin(), e[u].end(), cmp);
  pos[u] = ++dcnt;
  for (auto v : e[u]) dfs2(v);
}

void dfs3(int u) {
  static int originU[MAXN], originV[MAXN];
  static map<int, int> mp;

  int ulen = maxdep[u] - dep[u], vlen, tmp;
  add(1, 1, n, pos[u], 1);
  for (auto v : e[u]) {
    dfs3(v);
    if (v == e[u][0]) continue;
    vlen = maxdep[v] - dep[v];
    mp.clear();
    mp[0] = 1;
    mp[ulen + 1] = 0;
    tmp = 0;
    for (int i = 0; i <= vlen && i < lim; ++i) {
      originU[i] = query(1, 1, n, pos[u], pos[u] + min(i, lim - i - 1));
      originV[i] = query(1, 1, n, pos[v] + i, pos[v] + i);
    }
    for (int i = 0; i <= vlen && i < lim; ++i)
      if (i + 1 < lim - i) {
        (mp[i + 1] += originV[i]) %= P;
        (mp[min(lim - i, ulen + 1)] += P - originV[i]) %= P;
      }
    for (auto i = mp.begin(), j = ++mp.begin(); j != mp.end(); ++i, ++j) {
      tmp = (tmp + i->second) % P;
      multiply(1, 1, n, pos[u] + i->first, pos[u] + j->first - 1, tmp);
    }
    for (int i = 0; i <= vlen && i < lim; ++i)
      add(1, 1, n, pos[u] + i + 1, (LL)originU[i] * originV[i] % P);
  }
  ans = inc(ans, query(1, 1, n, pos[u], pos[u] + min(lim, ulen)));
}

inline int solve(int _lim) {
  build(1, 1, n);
  lim = _lim;
  ans = 0;
  dfs3(1);
  return ans;
}

inline int main() {
  int L, R;
  cin >> n >> L >> R;
  for (int i = 1, u, v; i < n; ++i) {
    cin >> u >> v;
    e[u].push_back(v), e[v].push_back(u);
  }
  dfs1(1, 0);
  dfs2(1);
  cout << qpow(solve(n)) * dec(solve(R), solve(L - 1)) % P;
  return 0;
}

}  // namespace BlueQuantum

int main() {
#ifndef ONLINE_JUDGE
#ifdef LOCAL
  freopen("/tmp/CodeTmp/testdata.in", "r", stdin);
  freopen("/tmp/CodeTmp/testdata.out", "w", stdout);
#else
  freopen("tree.in", "r", stdin);
  freopen("tree.out", "w", stdout);
#endif
#endif

  ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
  return BlueQuantum::main();
}
